home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 2003 June / macformat-130.iso / mac / Reviewed⁄Demos / Spearhead Demo / demota / pak1.pk3 / global / spotlight.scr < prev    next >
Encoding:
Text File  |  2002-10-21  |  27.0 KB  |  1,122 lines
  1. //    Spotlight system created by Mackey McCandlish.
  2. //
  3. //    Before level waittill prespawn "exec global/spotlight.scr".
  4. //    
  5. //    Used in m1l2a, m1l2b, m4l3, m6l2a, and probably some other place too.
  6. //
  7. //    Create a script_model with model "miscobj/searchlightbase.tik"
  8. //    
  9. //    Give it a targetname "spotlight".
  10. //    
  11. //    Create an AI and a turretweapon_german_mg42. Target the spotlight to the guy to the gun.
  12. //    
  13. //    Create a trigger_multiple around the spotlight with targetname "spotdamage". Assign it the damage flag.
  14. //    
  15. //    Create a bunch of script_origins (At least 5) with targetname "spotsearch". These are the places the spotlight will flick
  16. //    to when it is in "Alert" mode.
  17. //    
  18. //    Give the spotlight, spotdamage, and spotsearches the same #set value. Also give them a #group value. The way it works is,
  19. //    and spotlights that are supposed to share proximity have the same #set value, but every set of spotlight/spotdamage/spot
  20. //    searches have their own unique #group to associate them together. So a bunch of spotlights working together would all have
  21. //    #set 1, but each set of spotlight/spotdamage/spotsearches would have a different #group.
  22. //    
  23. //    Along the ground, create a loop of info_splinepaths. The targetname of one of the splinepaths must be "spotpath#1_#2"
  24. //    where #1 is the #set value of the spotlight that is supposed to shine on this path, and #2 is the #group value of that
  25. //    spotlight.
  26. //    
  27. //    Whenever the spotlight completes its loop, level.spottime["spot#1_#2"] is equal to the current level.time. This let's you
  28. //    do neat stuff like the SAS agent dodging the spotlight.
  29. //
  30. //    You can give vehicles coronas when their lights are on by doing:
  31. //        exec global/spotlight.scr::corona $truck "light left" 
  32. //        exec global/spotlight.scr::corona $truck "light right"
  33. //
  34. //    Where $truck is the name of the vehicle. "$truck.corona = 0" turns off the coronas (and you would normally do 
  35. //    "$truck anim idlenolights" at the same place to turn off the model lights).
  36.  
  37. main:
  38.  
  39.     level waittill prespawn
  40.  
  41.     // This script does not work in multiplayer
  42.     if ( level.gametype > 0 )
  43.     {
  44.         println ("The spotlight script does not work correctly in multiplayer" )
  45.            end
  46.     }
  47.  
  48.     if (level.spotrespondtime == NIL)
  49.         level.spotrespondtime = 5
  50.  
  51.     if (level.spot_burstmin == NIL)
  52.     level.spot_burstmin = 3
  53.  
  54.     if (level.spot_burstmax == NIL)
  55.         level.spot_burstmax = 6
  56.  
  57.     if (level.spot_burstdownmin == NIL)
  58.         level.spot_burstdownmin = 1
  59.  
  60.     if (level.spot_burstdownmax == NIL)
  61.         level.spot_burstdownmax = 3
  62.  
  63.  
  64.  
  65.     if ($spotdamage == NULL)
  66.         level.spotdamages = 0
  67.         else
  68.         level.spotdamages = $spotdamage.size
  69.  
  70.     if (level.spotdamages > 0)
  71.     {
  72.         level.spotdamage = exec global/makearray.scr $spotdamage
  73.  
  74.         for (local.i=1;local.i<level.spotdamages+1;local.i++)
  75.         {
  76.  
  77.             if (level.spotdamage[local.i].set == NIL)
  78.             {
  79.                 println ("Warning, spotdamage at " + level.spotdamage[local.i].origin + " has no #set, setting to 1")
  80.                 level.spotdamage[local.i].set = 1
  81.             }
  82.  
  83.             if (level.spotdamage[local.i].group == NIL)
  84.                 println ("Error, spotdamage at " + level.spotdamage[local.i].origin + " has no #group")
  85.                 else
  86.                 println ("Spawned spotdamage " + local.i)
  87.         }
  88.     }
  89.  
  90.  
  91.     if ($spotlight == NULL)
  92.         level.spotlights = 0
  93.         else
  94.         level.spotlights = $spotlight.size
  95.  
  96.     if (level.spotlights > 0)
  97.     {
  98.         level.spotlight = exec global/makearray.scr $spotlight
  99.  
  100.         for (local.i=1;local.i<level.spotlights+1;local.i++)
  101.         {
  102.             level.spotlight[local.i] thread spotwatch
  103.  
  104.             if (level.spotlight[local.i].set == NIL)
  105.             {
  106.                 println ("Warning, spotlight at " + level.spotlight[local.i].origin + " has no #set, setting to 1")
  107.                 level.spotlight[local.i].set = 1
  108.             }
  109.  
  110.             if (level.spotlight[local.i].group == NIL)
  111.                 println ("Error, spotlight at " + level.spotlight[local.i].origin + " has no #group")
  112.                 else
  113.                 println ("Spawned spotlight " + local.i)
  114.  
  115.             for (local.p=1;local.p<level.spotdamages+1;local.p++)
  116.             {
  117.                 if ((level.spotdamage[local.p].set == level.spotlight[local.i].set) && (level.spotdamage[local.p].group == level.spotlight[local.i].group))
  118.                     level.spotlight[local.i].damage = level.spotdamage[local.p]
  119.             }
  120.  
  121.             if (level.spotplayertime[level.spotlight[local.i].set] == NIL)
  122.                 thread spottracker level.spotlight[local.i].set
  123.  
  124.         }
  125.     }
  126.  
  127.  
  128.     if ($spotsearch == NULL)
  129.         level.spotsearchs = 0
  130.         else
  131.         level.spotsearchs = $spotsearch.size
  132.  
  133.     if (level.spotsearchs > 0)
  134.     {
  135.         level.spotsearch = exec global/makearray.scr $spotsearch
  136.  
  137.         for (local.i=1;local.i<level.spotsearchs+1;local.i++)
  138.         {
  139.             level.spotsearch[local.i] hide
  140.             level.spotsearch[local.i] notsolid
  141.  
  142.             if (level.spotsearch[local.i].set == NIL)
  143.             {
  144.                 println ("Warning, spotsearch at " + level.spotsearch[local.i].origin + " has no #set, setting to 1")
  145.                 level.spotsearch[local.i].set = 1
  146.             }
  147.  
  148.             if (level.spotsearch[local.i].group == NIL)
  149.                 println ("Error, spotsearch at " + level.spotsearch[local.i].origin + " has no #group")
  150.                 else
  151.                 println ("Spawned spotsearch " + local.i)
  152.         }
  153.     }
  154.  
  155.  
  156.     if ($spotcover == NULL)
  157.         level.spotcovers = 0
  158.         else
  159.         level.spotcovers = $spotcover.size
  160.  
  161.     if (level.spotcovers > 0)
  162.         level.spotcover = exec global/makearray.scr $spotcover
  163.  
  164.  
  165.     if (level.spottarget == NIL)
  166.     level.spottarget = $player
  167.  
  168.     level waittill spawn
  169.  
  170.     while (isalive $player)
  171.     {
  172.         if !(isalive level.spottarget)
  173.         {
  174. //            println "level spottarget is the player!"
  175.             level.spottarget = $player
  176.             
  177.  
  178.             for (local.i=1;local.i<level.spotlights+1;local.i++)
  179.             {
  180.                 level.spotplayertime[level.spotlight[local.i].set] = level.time - 5
  181.                 level.spotplayer[level.spotlight[local.i].set] = 0
  182.                 level.spotnervous[level.spotlight[local.i].set]++
  183.             }
  184.         }
  185.  
  186.         wait 3
  187.     }
  188.  
  189. end
  190.  
  191. spotpath:
  192.  
  193.     local.path = $("spotpath" + self.set + "_" + self.group)
  194.     while (self.checkdeath == 0)
  195.     {
  196.         level.spottime[("spot" + self.set + "_" + self.group)] = level.time
  197.         self.org.origin = local.path.origin
  198.         self.org flypath local.path 250 750 200
  199.         self.org waitmove
  200.     }
  201. end
  202.  
  203. spotdamage:
  204.     while (1)
  205.     {
  206.         self.damage waittill trigger
  207.         if (parm.other != $("world"))
  208.         {
  209.             self.destroyed = 1
  210.  
  211.             if (self.checkdeath != 1)
  212.             {
  213.                 self.checkdeath = 1
  214.                 level.spotnervous[self.set]++
  215.             }
  216.  
  217.             end
  218.         }
  219.     }
  220. end
  221.  
  222. spotowner:
  223.     thread spotowner_death
  224.     self hearing 2000
  225.     self sight 0
  226.     local.ent = spawn script_origin
  227.     local.ent.origin = self.origin
  228.     self leash 0
  229.     self tether local.ent
  230.     self mindist 0
  231.     self maxdist 1
  232.     self exec global/disable_ai.scr
  233.     self.fastcheck = 0
  234.     local.shooting = 0
  235. //    self.gun bulletspread 100 100
  236.     self.on_target = 0
  237.     self.visible = 1
  238.  
  239.  
  240.     local.ent2 = spawn script_origin
  241.     local.org = angles_toforward (self.gun.angles)
  242.     local.org = (local.org * 150) + (self.gun.origin)
  243.     local.ent2.origin = local.org
  244.  
  245.  
  246.     while (self.parent.checkdeath != 1)
  247.     {
  248.         wait (randomint(level.spotrespondtime) + 1.5)
  249.  
  250.         if ((level.spotplayer[self.parent.set] == 1) && (self.parent.on_target == 1))
  251.         {
  252.             //*** If the spotlight can see the player, the gunner shoots 
  253.  
  254.             self.gun setAimTarget level.spottarget
  255. //            self.gun burstFireSettings 0.5 2 1 2
  256.             self.gun burstFireSettings level.spot_burstmin level.spot_burstmax level.spot_burstdownmin level.spot_burstdownmax
  257. //            self.gun maxyawoffset 45
  258.             self.gun startFiring
  259.             local.shooting = 1
  260.         }
  261.         else
  262.         if (local.shooting == 1)
  263.         if (( level.spotplayer[self.parent.set] != 1 ) || (self.parent.on_target != 1))
  264.         {
  265.             wait 4
  266.  
  267.             self.gun clearAimTarget
  268.             self.gun stopFiring
  269.             self.gun setAimTarget local.ent2
  270. //            self.gun maxyawoffset 45
  271.             local.shooting = 0
  272.         }
  273.  
  274.         wait 1
  275.     }
  276.  
  277.     self.on_target_time = 0
  278.     while (1)
  279.     {
  280.         wait (randomint(level.spotrespondtime) + 1.5)
  281.  
  282.         if (self.visible == 1)
  283.         {
  284.             if (self cansee level.spottarget)
  285.             {
  286.                 //*** If the spotlight can see the player, the gunner shoots 
  287.  
  288.                 self.gun setAimTarget level.spottarget
  289.                 self.gun burstFireSettings level.spot_burstmin level.spot_burstmax level.spot_burstdownmin level.spot_burstdownmax
  290.     //            self.gun maxyawoffset 45
  291.                 self.gun startFiring
  292.                 local.shooting = 1
  293.             }
  294.             else
  295.             if (local.shooting == 1)
  296.             if ( level.spotplayer[self.parent.set] != 1 )
  297.             {    
  298.                 wait 5
  299.  
  300.                 self.gun clearAimTarget
  301.                 self.gun stopFiring
  302.                 self.gun setAimTarget local.ent2
  303.     //            self.gun maxyawoffset 45
  304.                 local.shooting = 0
  305.             }
  306.         }
  307.         else
  308.         {
  309.             self.gun clearAimTarget
  310.             self.gun stopFiring
  311.         }
  312.  
  313.     }
  314. end
  315.  
  316. spotowner_death:
  317.     self waittill death
  318.  
  319.     self.gun clearAimTarget
  320.     self.gun stopFiring
  321.     self.parent.spotterdeath = 1
  322.  
  323.     for (local.i=1;local.i<level.spotlights+1;local.i++)
  324.     {
  325.         if (level.spotlight[local.i].set == self.parent.set)
  326.             level.spotlight[local.i].spotter threatbias 100
  327.     }
  328.  
  329.     level.spotplayer[self.parent.set] = 1
  330.     level.spotplayertime[self.parent.set] = level.time + 6
  331.     level.spotnervous[self.parent.set]++
  332.  
  333.  
  334.     /*
  335.  
  336.     if ((self.parent) && (self.parent.checkdeath != 1))
  337.     {
  338. //        self.parent.checkdeath = 1
  339. //        println "killed by owner"
  340.         level.spotnervous[self.parent.set]++
  341.     }
  342.     */
  343.  
  344.     group delete
  345.  
  346. end
  347. /*
  348.         println ("Enabled my AI!!")
  349.         self exec global/enable_ai.scr
  350.             wait 0.25
  351.  
  352.         while (self.thinkstate == "attack")
  353.             wait 1
  354.  
  355.         while (self.thinkstate != "attack")
  356.             wait 1
  357.  
  358.         println ("Disabled my AI!!")
  359.         self exec global/disable_ai.scr
  360.         wait 2
  361.  
  362.         level.spotnervous[self.parent.set]++
  363.         println ("Made spots of set " + self.parent.set + " nervous")
  364.  
  365.         while (level.time < self.parent.searchtime)
  366.             wait 1
  367.     }
  368.  
  369.     if (self.parent.checkdeath != 1)
  370.     {
  371.         self.parent.checkdeath = 1
  372.         println "killed by owner"
  373.         level.spotnervous[self.parent.set]++
  374.     }
  375. end
  376. */
  377.  
  378.  
  379. seepath:
  380.     local.ent = spawn script_model
  381.     local.ent model animal/cockroach.tik
  382.     local.ent scale 100
  383.     local.ent notsolid
  384.     local.ent glue self
  385. end
  386.  
  387.  
  388. spotwatch:
  389.     level waittill spawn
  390.  
  391.     if (self.target)
  392.     {
  393.         self.spotter = $(self.target)
  394.  
  395.         if (self.spotter.target)
  396.         {
  397.             self.spotter type_idle "machinegunner"
  398.             self.spotter type_attack "machinegunner"
  399.             self.spotter type_disguise "machinegunner"
  400.             self.spotter type_grenade "machinegunner"
  401.             self.spotter gun "MG42"
  402.             self.spotter.turret = self.spotter.target
  403.             println (self.spotter.turret + " and the target " + self.spotter.target)
  404.             self.spotter.gun = self.spotter.target
  405.         }
  406.         else
  407.             println ("Error, spotlight at " + level.spotlight[local.i].origin + " has no mg42 targetted to its gunner")
  408.     }
  409.     else
  410.         println ("Error, spotlight at " + level.spotlight[local.i].origin + " has no gunner targetted")
  411.  
  412.     self.health = 1
  413.     self scale 1
  414.     level.spotplayer[self.set] = 0
  415.     level.spotnervous[self.set] = 0
  416.     self.searchtime = level.time
  417.     self.lightdist = 0
  418.     self.spotterdeath = 0
  419.  
  420.     self.spotnervous = level.spotnervous[self.set]
  421.     local.light = spawn script_model
  422.     local.light model "fx/dummy.tik"
  423.     self.spotlight = local.light
  424.     if (getcvar(debug) == "1")
  425.         self.spotlight thread seepath
  426.     self.light = local.light
  427.  
  428.     local.light light (1.0 1.0 1.0)
  429.     local.light lightRadius 300
  430.     local.light lightOn
  431.     local.light notsolid
  432.  
  433.     self model "miscobj/searchlightbase.tik"
  434.     self.angles = (0 0 0)
  435.  
  436.     local.bulb = spawn script_model
  437.     local.bulb model "miscobj/searchlight.tik"
  438.     local.bulb scale 1
  439.     local.bulb.origin = self.origin + (0 0 32)
  440.     self.bulb = local.bulb
  441.  
  442.     local.bulb bind self
  443.     local.bulb notsolid
  444.  
  445.     local.flare = spawn script_model
  446.     local.flare model "fx/searchlight.tik"
  447.     local.flare.origin = self.origin + (64 0 64)
  448.     self.flare = local.flare
  449.     
  450.     local.flare bind self
  451.     local.flare notsolid
  452.  
  453.     local.org = spawn script_origin
  454.     local.org.origin = self.origin
  455.     self.org = local.org
  456.  
  457.     self.currentaim = self.org
  458.  
  459.     self notsolid
  460.     self.checkdeath = 0
  461. //    local.org anim start
  462.     local.org light (1.0 1.0 1.0)
  463.     local.org lightRadius 300
  464.     local.org lightOn
  465.     local.org notsolid
  466.     self thread spotpath
  467.     
  468.     self thread spotdamage
  469.     
  470.     self.spotter.health = 1
  471.     self.spotter.parent = self
  472.     self.spotter thread spotowner
  473. //    self.spotter thread alivecheck
  474.     
  475.     waitthread swaptarg        
  476.     self thread search
  477.     local.thread1 = parm.previousthread
  478.     self.mode = 0
  479.  
  480.     local.skip = level.time
  481.  
  482.     if (self.seekorigin == NIL)
  483.         self.seekorigin = self.origin
  484.  
  485.     local.curframe = 0
  486.  
  487.     local.threadtimer = level.time + 0.15
  488.     self thread light_corona
  489.  
  490.     while ((self.checkdeath == 0) && (isalive $(self.spotter)))
  491.     {
  492.         if (getcvar(spotlight) == "1")
  493.         if (self.on_target == 1)
  494.             println ("Spotlight" + self.set + "/" + self.group + " is ON target")
  495.             else
  496.             println ("Spotlight" + self.set + "/" + self.group + " is OFFarget")
  497.  
  498.  
  499.         if (self.on_target == 1)
  500.         {
  501.             self.on_target_time--
  502. //            if (level.time > self.on_target_time)
  503.             if (self.on_target_time < 1)
  504.             {
  505.                 self.on_target = 0
  506.                 self.spotter.gun stopFiring
  507.             }
  508. //            else
  509. //                println ("set/group " + self.set + "/" + self.group + " is ON TARGET")
  510.         }
  511. //        else
  512. //            println ("set/group " + self.set + "/" + self.group + " is OFF target")
  513.  
  514.  
  515.         if (self.currentaim == self.org)
  516.         {
  517.             self.spotlight.origin = self.org.origin
  518.             self waitthread aimspot
  519.  
  520.             if (self.fastcheck == 0)
  521.                 local.threadtimer = level.time + 0.2
  522.             else
  523.                 local.threadtimer = level.time
  524.         }
  525.         else
  526.         if (level.time > local.threadtimer)
  527.         {
  528.             self.spotlight.origin = trace self.bulb.origin self.currentaim.origin 0
  529.             self waitthread aimspot
  530.  
  531.  
  532.             if (self.fastcheck == 0)
  533.                 local.threadtimer = level.time + 0.2
  534.             else
  535.                 local.threadtimer = level.time
  536.         }
  537.  
  538.         if (level.spotnervous[self.set] != self.spotnervous)
  539.         {
  540.             if (self.on_target == 0)
  541.                 self.found_target = 0
  542.  
  543.             self.searchtime = level.time + 8 + randomint (3)
  544.             self.spotnervous = level.spotnervous[self.set]
  545.             self.currentaim = self.search
  546.             self.search.origin = self.org.origin
  547.         }
  548.  
  549.  
  550.         waitframe
  551.  
  552.         /*
  553.         if (game.detail == 1)
  554.             waitframe
  555.         else
  556.             wait 0.1
  557.         */
  558.  
  559.     }
  560.  
  561.  
  562.  
  563.     if !(isalive self.spotter)
  564.     {
  565.         while (self.checkdeath == 0)
  566.             wait 0.1
  567.     }
  568.         
  569.     local.bulb model "miscobj/searchlightoff.tik"
  570.     local.bulb notsolid
  571.  
  572.     if (self.destroyed != NIL)
  573.     {
  574.         self playsound explode_searchlight
  575.         exec global/model.scr self.origin models/fx/fx_spotlighthit
  576.     }
  577.  
  578.     if (local.thread1)
  579.     local.thread1 delete
  580.  
  581.  
  582.     self.org lightOff
  583.     local.light delete
  584.     self.search delete
  585.     local.flare delete
  586.     self.damage delete
  587.  
  588.  
  589. //    while (isalive $(self.spotter))
  590. //        wait 2
  591.  
  592. //    self delete
  593.  
  594. end
  595.  
  596. light_corona:
  597.     while (self.checkdeath == 0)
  598.     {    
  599.         local.org = self.currentaim.origin
  600.         local.vect1 = (local.org - self.origin)
  601.         local.vect1 = vector_toangles (local.vect1)
  602.         local.angles = self.angles
  603.         local.angles[1] = local.vect1[1]
  604. //        self.angles = local.angles
  605.         local.angles = self.angles
  606.         local.angles[0] = local.vect1[0] + 180
  607.         local.angles[1] = 0
  608. //        self.bulb.angles = local.angles
  609.  
  610.  
  611.         local.vect = self.origin - self.currentaim.origin
  612.         local.vect = vector_normalize (local.vect)
  613.         local.dist = 16 // was 32
  614.         
  615.         local.vect[0] = local.vect[0] * local.dist
  616.         local.vect[1] = local.vect[1] * local.dist
  617.         local.vect[2] = local.vect[2] * local.dist
  618.         self.flare.origin = self.bulb.origin - local.vect
  619.         self.flare scale 5
  620.  
  621.         local.vect = $player.origin - self.origin
  622.         local.vect = vector_normalize (local.vect)
  623.  
  624.         local.angles = angles_toforward ($player.angles)
  625.         local.vect[0] = local.vect[0] * local.angles[0]
  626.         local.vect[1] = local.vect[1] * local.angles[1]
  627.         local.vect[2] = local.vect[2] * local.angles[2]
  628.  
  629.  
  630.         local.org1 = $player.origin + (0 0 64)
  631.         local.ang1 = $player.angles
  632.  
  633.         local.org2 = self.bulb.origin
  634.         local.ang2 = local.vect1
  635.  
  636.         //println ("ang1 " + local.ang1 + " and ang2 " + local.ang2 + " and combined " + (local.ang1 + local.ang2))
  637.  
  638.         // local.returnvalue = the value that you should use for an alpha
  639.  
  640.         // local.v1 = angles_toforward local.ang1
  641.         local.v1 = vector_normalize (local.org1 - local.org2)
  642.         local.v2 = angles_toforward local.ang2
  643.  
  644.         local.f1 = local.v1[0] * local.v2[0] + local.v1[1] * local.v2[1] + local.v1[2] * local.v2[2]
  645.         if(local.f1 > 0)
  646.             local.returnvalue = local.f1 * local.f1
  647.         else
  648.             local.returnvalue = 0
  649.  
  650.         // corona
  651.         self.flare scale (local.returnvalue * 25)
  652.         waitframe
  653.     }
  654. end
  655.  
  656. /*
  657. alivecheck:
  658.     while (1)
  659.     {
  660.         wait 1
  661.         if (isalive self)
  662.         println "alive"
  663.         else
  664.         println "dead"
  665.     }
  666. end
  667. */
  668.  
  669. aimspot: 
  670.  
  671. //    self.seekorigin = trace $(self.targetname + "bulb").origin $(self.targetname + self.aimtarget).origin 0
  672.  
  673.  
  674. //    else
  675. //    self.spotlight.origin = self.org
  676.  
  677.  
  678.  
  679.     self.lightdist = 100 + ((vector_length(self.origin - self.spotlight.origin)) * 0.15)
  680.     self.light lightRadius self.lightdist
  681.  
  682.     local.org = self.currentaim.origin
  683.     local.vect1 = (local.org - self.origin)
  684.     local.vect1 = vector_toangles (local.vect1)
  685.     local.angles = self.angles
  686.     local.angles[1] = local.vect1[1]
  687.     self.angles = local.angles
  688.     local.angles = self.angles
  689.     local.angles[0] = local.vect1[0] + 180
  690.     local.angles[1] = 0
  691.     self.bulb.angles = local.angles
  692.  
  693.  
  694.  
  695.     local.spottarget = level.spottarget
  696.     local.spottargetorigin = level.spottarget.origin
  697.  
  698. //    if (level.spot
  699.     if (vector_length(self.spotlight.origin - local.spottargetorigin) < self.lightdist)
  700.     {
  701.         local.vect = trace self.spotlight.origin local.spottargetorigin 1
  702.         if ((local.vect[0] == local.spottargetorigin[0]) && (local.vect[1] == local.spottargetorigin[1]) && (local.vect[2] == local.spottargetorigin[2]))
  703.         {
  704.             local.break = 0
  705.  
  706.             for (local.i=1;local.i<level.spotcovers+1;local.i++)
  707.             {
  708.                 if (local.spottarget istouching level.spotcover[local.i])
  709.                 local.break = 1
  710.             }
  711.  
  712.             if (($player.is_disguised == 1) && (level.spottarget == $player))    
  713.                 local.break = 1
  714.  
  715.             if (local.break == 0) 
  716.             {
  717.  
  718.                 self.on_target = 1
  719.                 self.found_target = 1
  720.  
  721.                 if (level.spotplayer[self.set] != 1)
  722.                 {
  723.                     local.trans = 0
  724.                     level.spotnervous[self.set]++
  725.                 }
  726.                     
  727.                 self.on_target_time = 2 // = level.time + 0.5
  728.  
  729.                 level.spotplayer[self.set] = 1        
  730.                 level.spotplayertime[self.set] = level.time + 6
  731.                 self.spotplayer = 1
  732.                 self.currentaim = self.search
  733.                 self.searchtime =  level.time + 2 + randomint (3)
  734.             }
  735.             else
  736.             {
  737.                 self.on_target = 0
  738.                 self.spotter.gun stopFiring
  739.             }
  740.  
  741.         }
  742.     }
  743.  
  744.     if (level.spotplayer[self.set] == 1)
  745.         self.search.origin = self.spotlight.origin
  746. end
  747.  
  748. spottracker local.set:
  749.     level.spotplayertime[local.set] = 1
  750.     level waittill spawn
  751.     wait 2
  752.  
  753.     level.spotplayertime[local.set] = level.time - 5
  754.  
  755.     while (1)
  756.     {
  757. //            println ("time left " + (level.spotplayertime[local.set] - level.time))
  758.  
  759.         if ( level.time > level.spotplayertime[local.set] )
  760.         {
  761.             level.spotplayer[local.set] = 0
  762.         }
  763.         else
  764.         {
  765.             level.spotplayer[local.set] = 1
  766.         }
  767.  
  768.         wait 0.25
  769.  
  770. //    level.spotplayertime
  771.     }
  772. end
  773.  
  774.  
  775. swaptarg:
  776.     local.search = spawn script_origin
  777.     self.search = local.search
  778.  
  779.     local.search.origin = self.org.origin
  780.     /*
  781.     local.search light (1.0 1.0 1.0)
  782.     local.search lightRadius 300
  783.     local.search lightOn
  784.     local.search notsolid
  785.     local.search lightOff
  786.     */
  787.  
  788.     self.searchnum = -1
  789. end
  790.  
  791. search:
  792.  
  793.     local.trans = 0
  794.     local.trans2 = 0
  795.     self.lastorigin = self.origin
  796.     self.found_target = 0
  797.  
  798.     while (self.checkdeath == 0)
  799.     {
  800.         if (self.currentaim != self.search)
  801.         {
  802.             local.trans = 0
  803.             self.search.origin =  self.org.origin
  804.             local.start =  self.org.origin
  805.         }
  806.  
  807.  
  808.         if (level.spotplayer[self.set] == 1)
  809.         {
  810.  
  811.             if (self.found_target == 1)
  812.             {
  813.                 if (self.on_target == 1)
  814.                 {
  815.                     self.fastcheck = 1
  816.                     local.org = self.search.origin
  817.                     local.dest = level.spottarget.origin
  818.                     local.trans = 0.1
  819.                         for (local.i=0;local.i<3;local.i++)
  820.                         local.org[local.i] = (local.org[local.i] * (1 - local.trans)) + (local.dest[local.i] * local.trans)
  821.                             self.search.origin = local.org
  822.                 }
  823.                 else
  824.                 {
  825.                     self.fastcheck = 1
  826.                     local.org = self.lastorigin
  827.                     local.dest = self.lastorigin
  828.                     local.trans = 0.1
  829.                         for (local.i=0;local.i<3;local.i++)
  830.                         local.org[local.i] = (local.org[local.i] * (1 - local.trans)) + (local.dest[local.i] * local.trans)
  831.                             self.search.origin = local.org
  832.                 }
  833.             }
  834.             else
  835.             {
  836.                 self.fastcheck = 1
  837.                 local.org = self.search.origin
  838.                 local.dest = level.spottarget.origin
  839.                 local.trans = 0.1
  840.                     for (local.i=0;local.i<3;local.i++)
  841.                     local.org[local.i] = (local.org[local.i] * (1 - local.trans)) + (local.dest[local.i] * local.trans)
  842.                         self.search.origin = local.org
  843.             }
  844.  
  845.         }
  846.         else
  847.         if (level.time > self.searchtime)
  848.         {
  849.             self.fastcheck = 1
  850.  
  851.             local.org = self.search.origin
  852.             local.dest = self.org.origin
  853.  
  854.             for (local.i=0;local.i<3;local.i++)
  855.                 local.org[local.i] = (local.org[local.i] * (1 - local.trans2)) + (local.dest[local.i] * local.trans2)
  856.  
  857.             self.search.origin = local.org
  858.             local.trans2 = local.trans2 + 0.01
  859.     
  860.  
  861.             if (self.spotplayer == 1)
  862.             {
  863.                 self.spotplayer = 0
  864.                 self.searchtime = level.time + 5 + randomint(5)
  865.  
  866.                 self.searchnum = -1 
  867.                 local.trans = 1
  868.     
  869.                 wait (0.4 + randomfloat(1))
  870.             }
  871.             else
  872.             if (local.trans2 > 1.0)
  873.             {
  874.                 self.currentaim = self.org
  875.                 self.searchtime = level.time + 99999
  876.                 self.fastcheck = 0
  877.  
  878.             }
  879.  
  880.         }
  881.         else
  882.         {
  883.             
  884.             local.trans2 = 0
  885.  
  886.             if ((local.trans == 1) || (self.searchnum == -1))
  887.             {
  888.                 /*
  889.                 local.searcharray = -1
  890.                 local.searches = 0
  891.                 for (local.i=1;local.i<level.spotsearchs+1;local.i++)
  892.                 {
  893.                     if (self.set == level.spotsearch[local.i].set)
  894.                     local.searcharray
  895.                 }
  896.                 */
  897.  
  898.                 self.fastcheck = 1
  899.                 local.oldnum = self.searchnum
  900.                 while (self.searchnum == local.oldnum)
  901.                 {
  902.                     
  903.                     self.searchnum = randomint(level.spotsearchs) + 1
  904.                     
  905.                     if ((level.spotsearch[self.searchnum].set == self.set) && (level.spotsearch[self.searchnum].group == self.group))
  906.                     {
  907.                         local.start = self.search.origin
  908.                         local.trans = 0
  909.                         local.transrate = 0.01
  910.                         local.transratemax = 0.12
  911.                         local.transratemax = 0.12
  912.                         local.transratemin = 0.03
  913.                         
  914.                         wait (0.4 + randomfloat(1))
  915.                     }
  916.                     else
  917.                     self.searchnum = local.oldnum
  918.  
  919.                     waitframe
  920.                 }
  921.             }
  922.  
  923.             local.org = local.start
  924.             local.dest = level.spotsearch[self.searchnum].origin
  925.  
  926.             for (local.i=0;local.i<3;local.i++)
  927.                 local.org[local.i] = (local.org[local.i] * (1 - local.trans)) + (local.dest[local.i] * local.trans)
  928.  
  929.             self.search.origin = local.org
  930.             local.trans = local.trans + local.transrate
  931.  
  932.             if (local.trans > 1)
  933.                 local.trans = 1
  934.             if (local.trans < 0.7)
  935.             {
  936.                 if (local.transrate < local.transratemax)
  937.                 local.transrate = local.transrate + 0.005
  938.             }
  939.             else
  940.             {
  941.                 if (local.transrate > local.transratemin)
  942.                 local.transrate = local.transrate - 0.01
  943.             }
  944.         }
  945.         waitframe
  946.         self.lastorigin = local.org
  947.     }
  948.  
  949. end
  950.  
  951.  
  952. // light left   light right
  953. corona local.obj local.tag: 
  954.  
  955.     // local.obj is the object with the light on it
  956.     // local.tag is the tag where the light appears
  957.  
  958.     local.flare = spawn script_model
  959.     local.flare model "fx/searchlight.tik"
  960.     local.flare notsolid
  961.     
  962.     local.obj.corona = 1
  963.  
  964. //    local.flare.origin = local.obj gettagposition local.tag
  965. //    local.flare bind local.obj
  966.     local.flare attach local.obj local.tag 0 ( 0 0 0 )
  967.  
  968.  
  969.     while ((isalive local.obj) && (local.obj.corona == 1))
  970.     {
  971.  
  972.         local.vect = $player.origin - local.flare.origin
  973.         local.vect = vector_normalize (local.vect)
  974.  
  975.         local.angles = angles_toforward ($player.angles)
  976.         local.vect[0] = local.vect[0] * local.angles[0]
  977.         local.vect[1] = local.vect[1] * local.angles[1]
  978.         local.vect[2] = local.vect[2] * local.angles[2]
  979.  
  980.         local.org1 = $player.origin + (0 0 64)
  981.         local.ang1 = $player.angles
  982.  
  983.         local.org2 = local.flare.origin
  984.         local.ang2 = local.obj.angles
  985.  
  986.         local.v1 = vector_normalize (local.org1 - local.org2)
  987.         local.v2 = angles_toforward local.ang2
  988.  
  989.         local.f1 = local.v1[0] * local.v2[0] + local.v1[1] * local.v2[1] + local.v1[2] * local.v2[2]
  990.         if(local.f1 > 0)
  991.             local.returnvalue = local.f1 * local.f1
  992.         else
  993.             local.returnvalue = 0
  994.  
  995.         local.flare scale (local.returnvalue * 5)
  996.         waitframe
  997.  
  998.     }
  999.     
  1000.     if ((isalive local.obj) && (local.obj.corona == 0))
  1001.         local.flare delete
  1002.  
  1003. end
  1004.  
  1005.  
  1006. // light left   light right
  1007. deadcorona local.obj local.tag: 
  1008.  
  1009.     // local.obj is the object with the light on it
  1010.     // local.tag is the tag where the light appears
  1011.  
  1012.     local.flare = spawn script_model
  1013.     local.flare model "fx/searchlight.tik"
  1014.     local.flare notsolid
  1015.     
  1016.     local.obj.corona = 1
  1017.  
  1018. //    local.flare.origin = local.obj gettagposition local.tag
  1019. //    local.flare bind local.obj
  1020.     local.flare attach local.obj local.tag 0 ( 0 0 0 )
  1021.  
  1022.     while (local.obj.corona == 1)
  1023.     {
  1024.  
  1025.         local.vect = $player.origin - local.flare.origin
  1026.         local.vect = vector_normalize (local.vect)
  1027.  
  1028.         local.angles = angles_toforward ($player.angles)
  1029.         local.vect[0] = local.vect[0] * local.angles[0]
  1030.         local.vect[1] = local.vect[1] * local.angles[1]
  1031.         local.vect[2] = local.vect[2] * local.angles[2]
  1032.  
  1033.         local.org1 = $player.origin + (0 0 64)
  1034.         local.ang1 = $player.angles
  1035.  
  1036.         local.org2 = local.flare.origin
  1037.         local.ang2 = local.obj.angles
  1038.  
  1039.         local.v1 = vector_normalize (local.org1 - local.org2)
  1040.         local.v2 = angles_toforward local.ang2
  1041.  
  1042.         local.f1 = local.v1[0] * local.v2[0] + local.v1[1] * local.v2[1] + local.v1[2] * local.v2[2]
  1043.         if(local.f1 > 0)
  1044.             local.returnvalue = local.f1 * local.f1
  1045.         else
  1046.             local.returnvalue = 0
  1047.  
  1048.         local.flare scale (local.returnvalue * 5)
  1049.         waitframe
  1050.  
  1051.     }
  1052.             
  1053.     local.flare delete
  1054.  
  1055. end
  1056.  
  1057. // light middle
  1058. // a larger scaled corona befitting a train
  1059. traincorona local.obj local.tag: 
  1060.  
  1061.     // local.obj is the object with the light on it
  1062.     // local.tag is the tag where the light appears
  1063.  
  1064.     local.flare = spawn script_model
  1065.     local.flare model "fx/searchlight.tik"
  1066.     local.flare notsolid
  1067.     
  1068.     local.obj.corona = 1
  1069.  
  1070. //    local.flare.origin = local.obj gettagposition local.tag
  1071. //    local.flare bind local.obj
  1072.     local.flare attach local.obj local.tag 0 ( 0 0 0 )
  1073.  
  1074.     while (local.obj.corona == 1)
  1075.     {
  1076.  
  1077.         local.vect = $player.origin - local.flare.origin
  1078.         local.vect = vector_normalize (local.vect)
  1079.  
  1080.         local.angles = angles_toforward ($player.angles)
  1081.         local.vect[0] = local.vect[0] * local.angles[0]
  1082.         local.vect[1] = local.vect[1] * local.angles[1]
  1083.         local.vect[2] = local.vect[2] * local.angles[2]
  1084.  
  1085.         local.org1 = $player.origin + (0 0 64)
  1086.         local.ang1 = $player.angles
  1087.  
  1088.         local.org2 = local.flare.origin
  1089.         local.ang2 = local.obj.angles
  1090.  
  1091.         local.v1 = vector_normalize (local.org1 - local.org2)
  1092.         local.v2 = angles_toforward local.ang2
  1093.  
  1094.         local.f1 = local.v1[0] * local.v2[0] + local.v1[1] * local.v2[1] + local.v1[2] * local.v2[2]
  1095.         if(local.f1 > 0)
  1096.             local.returnvalue = local.f1 * local.f1
  1097.         else
  1098.             local.returnvalue = 0
  1099.  
  1100.         local.flare scale (local.returnvalue * 10)
  1101.         waitframe
  1102.  
  1103.     }
  1104.             
  1105.     local.flare delete
  1106. end
  1107.  
  1108. flame:
  1109.     exec global/model.scr self.origin models/fx/fx_spotlighthit
  1110.     /*
  1111.     spawn emitters/fire "targetname" (self.targetname + "fire")
  1112.     $(self.targetname + "fire") light (1.0 0.8 0.0)
  1113.     $(self.targetname + "fire") lightOn
  1114.  
  1115.     spawn emitters/firesmoke "targetname" (self.targetname + "firesmoke")
  1116.     $(self.targetname + "firesmoke").origin = self.origin + (0 0 135)
  1117.     $(self.targetname + "firesmoke").angles = (270 0 0)
  1118.     $(self.targetname + "fire").origin = self.origin
  1119.     */
  1120.  
  1121. end
  1122.